package com.interview.a_多线程.c_停止线程.e_停止线程_错误方法.b_volatile_标记问题.b_不行了;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**
 * volatile 关键字，多个线程之间都可以看到 它声明的值
 * <p>
 * 生产者的生产很快
 * 消费者的消费很慢
 * 此时 生产者线程 的 阻塞队列（storage.put(count);）  进入阻塞状态无法继续执行
 * 此时 更新标记状态 无法停止线程
 */

public class StopThread {

    public static void main(String[] args) throws InterruptedException {

        //阻塞队列 满了不能存，空了不能取
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(10);

        //创建生产者
        Producer producer = new Producer(arrayBlockingQueue);
        Thread thread = new Thread(producer);
        thread.start();
        Thread.sleep(3000);

        //创建消费者
        Consumer consumer = new Consumer(arrayBlockingQueue);
        while (consumer.needConsume()) {
            System.out.println(consumer.storage.take() + "被消费...");
            Thread.sleep(1000);
        }
        //消费完毕
        System.out.println("消费者消费完毕，不会再进行消费了！");

        //错误 停止生产
        producer.isCancel = true;

        //正确 停止生产
        //        thread.interrupt();
    }
}

/**
 * 生产者
 */
class Producer implements Runnable {
    public volatile boolean isCancel = false;
    //阻塞队列
    BlockingQueue storage;

    public Producer(BlockingQueue storage) {
        this.storage = storage;
    }

    @Override
    public void run() {
        int count = 0;
        try {
            System.out.println("生产者开始生产.........");
            while (count < 100000 && !isCancel) {
                if (count % 10 == 0) {
                    storage.put(count);
                    System.out.println(count + " 可以被 10整除  被放到仓库中");
                }
                count++;
                //                System.out.println("count = " + count);
                //                Thread.sleep(100);
            }
            System.out.println("生产者停止运行！");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 消费者
 */
class Consumer {
    //阻塞队列
    BlockingQueue storage;

    Consumer(BlockingQueue storage) {
        this.storage = storage;
    }

    /**
     * 是否需要消费
     */
    public boolean needConsume() {
        double random = Math.random();
        System.out.println(random);
        return random < 0.95;
    }
}